{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b5c3628c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets,transforms\n",
    "import time\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c312705c",
   "metadata": {},
   "source": [
    "# GoogLeNet InceptionV2 的 PyTorch 复现（猫狗大战）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c588198",
   "metadata": {},
   "source": [
    "## 1. 数据集制作"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "042e856d",
   "metadata": {},
   "source": [
    "在论文中作者使用的是ILSVRC 2012比赛数据集，该数据集非常大（有138G），下载、训练都很消耗时间，我们在复现的时候就不用这个数据集了。由于MNIST、CIFAR10、CIFAR100这些数据集图片尺寸都较小，不符合GoogLeNet网络输入尺寸227x227的要求，因此我们改用kaggle比赛经典的“猫狗大战”数据集了。\n",
    "\n",
    "该数据集包含的训练集总共25000张图片，猫狗各12500张，带标签；测试集总共12500张，不带标签。我们仅使用带标签的25000张图片，分别拿出2500张猫和狗的图片作为模型的验证集。我们按照以下目录层级结构，将数据集图片放好。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac27c36d",
   "metadata": {},
   "source": [
    "![](./images/path.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4b4f3b9",
   "metadata": {},
   "source": [
    "为了方便大家训练，我们将该数据集放在百度云盘，下载链接： 链接：https://pan.baidu.com/s/1UEOzxWWMLCUoLTxdWUkB4A 提取码：cdue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d3e5ce",
   "metadata": {},
   "source": [
    "### 1.1 制作图片数据的索引"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b38d9dc",
   "metadata": {},
   "source": [
    "准备好数据集之后，我们需要用PyTorch来读取并制作可以用来训练和测试的数据集。对于训练集和测试集，首先要分别制作对应的图片数据索引，即train.txt和test.txt两个文件，每个txt中包含每个图片的目录和对应类别class（cat对应的label=0，dog对应的label=1）。示意图如下："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4a0ee17",
   "metadata": {},
   "source": [
    "![](./images/index.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bfed642",
   "metadata": {},
   "source": [
    "制作图片数据索引train.txt和test.txt两个文件的python脚本程序如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "322bfea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "train_txt_path = os.path.join(\"data\", \"catVSdog\", \"train.txt\")\n",
    "train_dir = os.path.join(\"data\", \"catVSdog\", \"train_data\")\n",
    "valid_txt_path = os.path.join(\"data\", \"catVSdog\", \"test.txt\")\n",
    "valid_dir = os.path.join(\"data\", \"catVSdog\", \"test_data\")\n",
    "\n",
    "def gen_txt(txt_path, img_dir):\n",
    "    f = open(txt_path, 'w')\n",
    "    \n",
    "    for root, s_dirs, _ in os.walk(img_dir, topdown=True):  # 获取 train文件下各文件夹名称\n",
    "        for sub_dir in s_dirs:\n",
    "            i_dir = os.path.join(root, sub_dir)             # 获取各类的文件夹 绝对路径\n",
    "            img_list = os.listdir(i_dir)                    # 获取类别文件夹下所有png图片的路径\n",
    "            for i in range(len(img_list)):\n",
    "                if not img_list[i].endswith('jpg'):         # 若不是png文件，跳过\n",
    "                    continue\n",
    "                #label = (img_list[i].split('.')[0] == 'cat')? 0 : 1 \n",
    "                label = img_list[i].split('.')[0]\n",
    "                # 将字符类别转为整型类型表示\n",
    "                if label == 'cat':\n",
    "                    label = '0'\n",
    "                else:\n",
    "                    label = '1'\n",
    "                img_path = os.path.join(i_dir, img_list[i])\n",
    "                line = img_path + ' ' + label + '\\n'\n",
    "                f.write(line)\n",
    "    f.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    gen_txt(train_txt_path, train_dir)\n",
    "    gen_txt(valid_txt_path, valid_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "611da85e",
   "metadata": {},
   "source": [
    "运行脚本之后就在./data/catVSdog/目录下生成train.txt和test.txt两个索引文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "568c1864",
   "metadata": {},
   "source": [
    "### 1.2 构建Dataset子类"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d148c9d0",
   "metadata": {},
   "source": [
    "PyTorch 加载自己的数据集，需要写一个继承自torch.utils.data中Dataset类，并修改其中的__init__方法、__getitem__方法、__len__方法。默认加载的都是图片，__init__的目的是得到一个包含数据和标签的list，每个元素能找到图片位置和其对应标签。然后用__getitem__方法得到每个元素的图像像素矩阵和标签，返回img和label。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ed18959c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "class MyDataset(Dataset):\n",
    "    def __init__(self, txt_path, transform = None, target_transform = None):\n",
    "        fh = open(txt_path, 'r')\n",
    "        imgs = []\n",
    "        for line in fh:\n",
    "            line = line.rstrip()\n",
    "            words = line.split()\n",
    "            imgs.append((words[0], int(words[1]))) # 类别转为整型int\n",
    "            self.imgs = imgs \n",
    "            self.transform = transform\n",
    "            self.target_transform = target_transform\n",
    "    def __getitem__(self, index):\n",
    "        fn, label = self.imgs[index]\n",
    "        img = Image.open(fn).convert('RGB') \n",
    "        #img = Image.open(fn)\n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img) \n",
    "        return img, label\n",
    "    def __len__(self):\n",
    "        return len(self.imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6ec0528",
   "metadata": {},
   "source": [
    "getitem是核心函数。self.imgs是一个list，self.imgs[index]是一个str，包含图片路径，图片标签，这些信息是从上面生成的txt文件中读取；利用Image.open对图片进行读取，注意这里的img是单通道还是三通道的；self.transform(img)对图片进行处理，这个transform里边可以实现减均值、除标准差、随机裁剪、旋转、翻转、放射变换等操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1abcf6dc",
   "metadata": {},
   "source": [
    "### 1.3 加载数据集和数据预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0abcf641",
   "metadata": {},
   "source": [
    "当Mydataset构建好，剩下的操作就交给DataLoder来加载数据集。在DataLoder中，会触发Mydataset中的getiterm函数读取一张图片的数据和标签，并拼接成一个batch返回，作为模型真正的输入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "5493e72a",
   "metadata": {},
   "outputs": [],
   "source": [
    "pipline_train = transforms.Compose([\n",
    "    #transforms.RandomResizedCrop(224),\n",
    "    transforms.RandomHorizontalFlip(),  #随机旋转图片\n",
    "    #将图片尺寸resize到224x224\n",
    "    transforms.Resize((224,224)),\n",
    "    #将图片转化为Tensor格式\n",
    "    transforms.ToTensor(),\n",
    "    #正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "pipline_test = transforms.Compose([\n",
    "    #将图片尺寸resize到224x224\n",
    "    transforms.Resize((224,224)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "train_data = MyDataset('./data/catVSdog/train.txt', transform=pipline_train)\n",
    "test_data = MyDataset('./data/catVSdog/test.txt', transform=pipline_test)\n",
    "\n",
    "#train_data 和test_data包含多有的训练与测试数据，调用DataLoader批量加载\n",
    "trainloader = torch.utils.data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(dataset=test_data, batch_size=32, shuffle=False)\n",
    "# 类别信息也是需要我们给定的\n",
    "classes = ('cat', 'dog') # 对应label=0，label=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf31738",
   "metadata": {},
   "source": [
    "在数据预处理中，我们将图片尺寸调整到224x224，符合VGGNet网络的输入要求。均值mean = [0.5, 0.5, 0.5]，方差std = [0.5, 0.5, 0.5]，然后使用transforms.Normalize进行归一化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86ac6b8b",
   "metadata": {},
   "source": [
    "我们来看一下最终制作的数据集图片和它们对应的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "30703764",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "examples = enumerate(trainloader)\n",
    "batch_idx, (example_data, example_label) = next(examples)\n",
    "# 批量展示图片\n",
    "for i in range(4):\n",
    "    plt.subplot(1, 4, i + 1)\n",
    "    plt.tight_layout()  #自动调整子图参数，使之填充整个图像区域\n",
    "    img = example_data[i]\n",
    "    img = img.numpy() # FloatTensor转为ndarray\n",
    "    img = np.transpose(img, (1,2,0)) # 把channel那一维放到最后\n",
    "    img = img * [0.5, 0.5, 0.5] + [0.5, 0.5, 0.5]\n",
    "    #img = img * [0.229, 0.224, 0.225] + [0.485, 0.456, 0.406]\n",
    "    plt.imshow(img)\n",
    "    plt.title(\"label:{}\".format(example_label[i]))\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f56000d",
   "metadata": {},
   "source": [
    "## 2. 搭建 GoogLeNet InceptionV2 神经网络结构"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c9c40f5",
   "metadata": {},
   "source": [
    "源码部分 Inception V2 与论文中介绍的不完全一样，我们使用 PyTorch 复现的 Inception V2 结构如下图所示："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff522701",
   "metadata": {},
   "source": [
    "![](./images/googlenet_v2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27a460db",
   "metadata": {},
   "source": [
    "首先定义基本的 2d 卷积类，加入了 Batch Normalization，ReLU6是在ReLU的基础上，限制正值的上限6。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "d1e4980d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BasicConv2d(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, **kwargs):\n",
    "        super(ConvBasicReLU, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
    "        self.relu = nn.ReLU6(inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.relu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "32ee32a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvBNReLU(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, **kwargs):\n",
    "        super(ConvBNReLU, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
    "        self.bn = nn.BatchNorm2d(out_channels)\n",
    "        self.relu = nn.ReLU6(inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.bn(x)\n",
    "        x = self.relu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c88a03bb",
   "metadata": {},
   "source": [
    "InceptionV2_A 模块结构：\n",
    "\n",
    "![](./images/inceptionV2_A.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "b2ab9197",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV2_A(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV2_A, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=3, padding=1)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_3red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=3, padding=1),   # 保证输出大小等于输入大小\n",
    "            ConvBNReLU(out_channels_3, out_channels_3, kernel_size=3, padding=1)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cf05041",
   "metadata": {},
   "source": [
    "InceptionV2_B 模块结构：\n",
    "\n",
    "![](./images/inceptionV2_B.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "e6538c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV2_B(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV2_B, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2red, kernel_size=[1,3], padding=[0,1]),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[3,1], padding=[1,0])\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_3red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[1,3], padding=[0,1]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[3,1], padding=[1,0]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3red, kernel_size=[1,3], padding=[0,1]), \n",
    "            ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=[3,1], padding=[1,0])\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13d9daa6",
   "metadata": {},
   "source": [
    "InceptionV2_C 模块结构：\n",
    "\n",
    "![](./images/inceptionV2_C.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "198f5b49",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV2_C(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1, out_channels_2red, out_channels_2, out_channels_3red, out_channels_3, out_channels_4):\n",
    "        super(InceptionV2_C, self).__init__()\n",
    "\n",
    "        self.branch1 = ConvBNReLU(in_channels, out_channels_1, kernel_size=1)\n",
    "        \n",
    "        self.branch2_conv1x1 = ConvBNReLU(in_channels, out_channels_2red, kernel_size=1)\n",
    "        self.branch2_conv1x3 = ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[1,3],padding=[0,1])\n",
    "        self.branch2_conv3x1 = ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=[3,1],padding=[1,0])\n",
    "        \n",
    "        self.branch3_conv1x1 = ConvBNReLU(in_channels, out_channels_3red, kernel_size=1)\n",
    "        self.branch3_conv3x3 = ConvBNReLU(out_channels_3red, out_channels_3, kernel_size=3,padding=1)\n",
    "        self.branch3_conv1x3 = ConvBNReLU(out_channels_3, out_channels_3, kernel_size=[1,3],padding=[0,1])\n",
    "        self.branch3_conv3x1 = ConvBNReLU(out_channels_3, out_channels_3, kernel_size=[3,1],padding=[1,0])\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            ConvBNReLU(in_channels, out_channels_4, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2_tmp = self.branch2_conv1x1(x)\n",
    "        branch2 = torch.cat([self.branch2_conv1x3(branch2_tmp), self.branch2_conv3x1(branch2_tmp)], dim=1)\n",
    "        branch3_tmp = self.branch3_conv1x1(x)\n",
    "        branch3_tmp = self.branch3_conv3x3(branch3_tmp)\n",
    "        branch3 = torch.cat([self.branch3_conv1x3(branch3_tmp), self.branch3_conv3x1(branch3_tmp)], dim=1)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3143a999",
   "metadata": {},
   "source": [
    "InceptionV2_D 模块结构：\n",
    "\n",
    "![](./images/inceptionV2_D.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4e58ac59",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionV2_D(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels_1red, out_channels_1, out_channels_2red, out_channels_2):\n",
    "        super(InceptionV2_D, self).__init__()\n",
    "\n",
    "        self.branch1 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_1red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_1red, out_channels_1, kernel_size=3, stride=2,  padding=1)   \n",
    "        )\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            ConvBNReLU(in_channels, out_channels_2red, kernel_size=1),\n",
    "            ConvBNReLU(out_channels_2red, out_channels_2, kernel_size=3, stride=1, padding=1),  \n",
    "            ConvBNReLU(out_channels_2, out_channels_2, kernel_size=3, stride=2, padding=1) \n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e801256b",
   "metadata": {},
   "source": [
    "定义辅助分类器：\n",
    "\n",
    "结构：Pool——>1x1Conv——>5x5Conv——>FC——>softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fa607633",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionAux(nn.Module):\n",
    "    def __init__(self, in_channels, num_classes):\n",
    "        super(InceptionAux, self).__init__()\n",
    "        self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)\n",
    "        self.conv1 = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]\n",
    "        self.conv2 = BasicConv2d(128, 768, kernel_size=5)  # output[batch, 128, 4, 4]\n",
    "        self.fc = nn.Linear(768, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.averagePool(x)\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = F.dropout(x, 0.7, training=self.training)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfef4d9f",
   "metadata": {},
   "source": [
    "完整的 GoogLeNetV2 网络结构："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "179253aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GoogLeNetV2(nn.Module):\n",
    "    def __init__(self, num_classes=2, aux_logits=True, init_weights=False):\n",
    "        super(GoogLeNetV2, self).__init__()\n",
    "        self.aux_logits = aux_logits\n",
    "        \n",
    "        self.conv1 = ConvBNReLU(3, 64, kernel_size=7, stride=2, padding=3)\n",
    "        self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.conv2 = ConvBNReLU(64, 192, kernel_size=3, padding=1)\n",
    "        self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.inceptionA1 = InceptionV2_A(in_channels=192, out_channels_1=64, out_channels_2red=64, out_channels_2=64, out_channels_3red=64, out_channels_3=96, out_channels_4=32)\n",
    "        self.inceptionA2 = InceptionV2_A(in_channels=256, out_channels_1=64, out_channels_2red=64, out_channels_2=96, out_channels_3red=64, out_channels_3=96, out_channels_4=64)\n",
    "        self.inceptionD1 = InceptionV2_D(in_channels=320, out_channels_1red=128, out_channels_1=160, out_channels_2red=64, out_channels_2=96)\n",
    "        \n",
    "        self.inceptionB1 = InceptionV2_B(in_channels=576, out_channels_1=224, out_channels_2red=64, out_channels_2=96, out_channels_3red=96, out_channels_3=128, out_channels_4=128)\n",
    "        self.inceptionB2 = InceptionV2_B(in_channels=576, out_channels_1=192, out_channels_2red=96, out_channels_2=128, out_channels_3red=96, out_channels_3=128, out_channels_4=128)\n",
    "        self.inceptionB3 = InceptionV2_B(in_channels=576, out_channels_1=160, out_channels_2red=128, out_channels_2=160, out_channels_3red=128, out_channels_3=128, out_channels_4=128)\n",
    "        self.inceptionB4 = InceptionV2_B(in_channels=576, out_channels_1=96, out_channels_2red=128, out_channels_2=192, out_channels_3red=160, out_channels_3=160, out_channels_4=128)\n",
    "        self.inceptionD2 = InceptionV2_D(in_channels=576, out_channels_1red=128, out_channels_1=192, out_channels_2red=192, out_channels_2=256)\n",
    "        \n",
    "        self.inceptionC1 = InceptionV2_C(in_channels=1024, out_channels_1=352, out_channels_2red=192, out_channels_2=160, out_channels_3red=160, out_channels_3=112, out_channels_4=128)\n",
    "        self.inceptionC2 = InceptionV2_C(in_channels=1024, out_channels_1=352, out_channels_2red=192, out_channels_2=160, out_channels_3red=192, out_channels_3=112, out_channels_4=128)\n",
    "\n",
    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self.fc = nn.Linear(1024, num_classes)\n",
    "        if init_weights:\n",
    "            self._initialize_weights()\n",
    "\n",
    "    def forward(self, x):\n",
    "        #------ 输入块 ------#\n",
    "        # N x 3 x 224 x 224\n",
    "        x = self.conv1(x)\n",
    "        x = self.maxpool1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.maxpool2(x)\n",
    "        \n",
    "        #------ Inception ------#\n",
    "        # N x 192 x 28 x 28\n",
    "        x = self.inceptionA1(x)\n",
    "        x = self.inceptionA2(x)\n",
    "        x = self.inceptionD1(x)\n",
    "        x = self.inceptionB1(x)\n",
    "        x = self.inceptionB2(x)\n",
    "        x = self.inceptionB3(x)\n",
    "        x = self.inceptionB4(x)\n",
    "        x = self.inceptionD2(x)\n",
    "        x = self.inceptionC1(x)\n",
    "        x = self.inceptionC2(x)\n",
    "       \n",
    "        #------ 输出块 ------# \n",
    "        x = self.avgpool(x)\n",
    "        # N x 1024 x 1 x 1\n",
    "        x = torch.flatten(x, 1)\n",
    "        # N x 1024\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n",
    "                if m.bias is not None:\n",
    "                    nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c121abd",
   "metadata": {},
   "source": [
    "定义GoogLeNet类的时候，参数num_classes指的是类别的数量，由于我们这里的数据集只有猫和狗两个类别，因此这里的全连接层的神经元个数做了微调。num_classes=2，输出层也是两个神经元，不是原来的1000个神经元。这里的改动大家注意一下，根据实际数据集的类别数量进行调整。整个网络的其它结构跟论文中的完全一样。\n",
    "\n",
    "函数initialize_weights()是对网络参数进行初始化操作，这里我们默认选择关闭初始化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "235dd1f8",
   "metadata": {},
   "source": [
    "## 3. 将定义好的网络结构搭载到GPU/CPU，并定义优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "80bb292c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#创建模型，部署gpu\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model_name = \"googlenetV2\"\n",
    "model = GoogLeNetV2(num_classes=2, aux_logits=True, init_weights=False)\n",
    "model.to(device)\n",
    "#定义优化器\n",
    "loss_function = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0004)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c0aef7d",
   "metadata": {},
   "source": [
    "这里我们将参数init_weights设为True，进行参数初始化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0a65aa",
   "metadata": {},
   "source": [
    "## 4. 定义训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e4279263",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_runner(model, device, trainloader, loss_function, optimizer, epoch):\n",
    "    #训练模型, 启用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置为True\n",
    "    model.train()\n",
    "    total = 0\n",
    "    correct =0.0\n",
    "    \n",
    "    #enumerate迭代已加载的数据集,同时获取数据和数据下标\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "        #把模型部署到device上\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        #初始化梯度\n",
    "        optimizer.zero_grad()\n",
    "        #保存训练结果\n",
    "        #outputs = model(inputs)\n",
    "        logits = model(inputs)\n",
    "        #计算损失和\n",
    "        #loss = F.cross_entropy(outputs, labels)\n",
    "        loss = loss_function(logits, labels)\n",
    "        #获取最大概率的预测结果\n",
    "        #dim=1表示返回每一行的最大值对应的列下标\n",
    "        predict = logits.argmax(dim=1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predict == labels).sum().item()\n",
    "        #反向传播\n",
    "        loss.backward()\n",
    "        #更新参数\n",
    "        optimizer.step()\n",
    "        if i % 100 == 0:\n",
    "            #loss.item()表示当前loss的数值\n",
    "            print(\"Train Epoch{} \\t Loss: {:.6f}, accuracy: {:.6f}%\".format(epoch, loss.item(), 100*(correct/total)))\n",
    "            Loss.append(loss.item())\n",
    "            Accuracy.append(correct/total)\n",
    "    return loss.item(), correct/total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "651faf89",
   "metadata": {},
   "source": [
    "## 5. 定义测试过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "4ea94435",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_runner(model, device, testloader):\n",
    "    #模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值\n",
    "    #因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False\n",
    "    model.eval()\n",
    "    #统计模型正确率, 设置初始值\n",
    "    correct = 0.0\n",
    "    test_loss = 0.0\n",
    "    total = 0\n",
    "    #torch.no_grad将不会计算梯度, 也不会进行反向传播\n",
    "    with torch.no_grad():\n",
    "        for data, label in testloader:\n",
    "            data, label = data.to(device), label.to(device)\n",
    "            output = model(data)\n",
    "            test_loss += F.cross_entropy(output, label).item()\n",
    "            predict = output.argmax(dim=1)\n",
    "            #计算正确数量\n",
    "            total += label.size(0)\n",
    "            correct += (predict == label).sum().item()\n",
    "        #计算损失值\n",
    "        print(\"test_avarage_loss: {:.6f}, accuracy: {:.6f}%\".format(test_loss/total, 100*(correct/total)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd7367b",
   "metadata": {},
   "source": [
    "## 6. 运行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "9b5bacbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start_time 2022-02-25 10:01:43\n",
      "Train Epoch1 \t Loss: 0.738406, accuracy: 40.625000%\n",
      "Train Epoch1 \t Loss: 0.651659, accuracy: 63.567450%\n",
      "Train Epoch1 \t Loss: 0.493754, accuracy: 68.788868%\n",
      "Train Epoch1 \t Loss: 0.261762, accuracy: 72.217608%\n",
      "test_avarage_loss: 0.025843, accuracy: 67.280000%\n",
      "end_time:  2022-02-25 10:05:02 \n",
      "\n",
      "start_time 2022-02-25 10:05:02\n",
      "Train Epoch2 \t Loss: 0.428323, accuracy: 84.375000%\n",
      "Train Epoch2 \t Loss: 0.414527, accuracy: 83.787129%\n",
      "Train Epoch2 \t Loss: 0.226809, accuracy: 84.662624%\n",
      "Train Epoch2 \t Loss: 0.449475, accuracy: 85.802533%\n",
      "test_avarage_loss: 0.011273, accuracy: 85.140000%\n",
      "end_time:  2022-02-25 10:08:21 \n",
      "\n",
      "start_time 2022-02-25 10:08:21\n",
      "Train Epoch3 \t Loss: 0.351590, accuracy: 85.937500%\n",
      "Train Epoch3 \t Loss: 0.309867, accuracy: 89.573020%\n",
      "Train Epoch3 \t Loss: 0.185140, accuracy: 90.057525%\n",
      "Train Epoch3 \t Loss: 0.149795, accuracy: 90.417359%\n",
      "test_avarage_loss: 0.007759, accuracy: 89.340000%\n",
      "end_time:  2022-02-25 10:11:42 \n",
      "\n",
      "start_time 2022-02-25 10:11:42\n",
      "Train Epoch4 \t Loss: 0.166169, accuracy: 92.187500%\n",
      "Train Epoch4 \t Loss: 0.190698, accuracy: 92.264851%\n",
      "Train Epoch4 \t Loss: 0.154185, accuracy: 92.156405%\n",
      "Train Epoch4 \t Loss: 0.151532, accuracy: 92.426287%\n",
      "test_avarage_loss: 0.007266, accuracy: 90.720000%\n",
      "end_time:  2022-02-25 10:15:06 \n",
      "\n",
      "start_time 2022-02-25 10:15:06\n",
      "Train Epoch5 \t Loss: 0.184203, accuracy: 92.187500%\n",
      "Train Epoch5 \t Loss: 0.155260, accuracy: 94.090347%\n",
      "Train Epoch5 \t Loss: 0.133653, accuracy: 93.703358%\n",
      "Train Epoch5 \t Loss: 0.194607, accuracy: 93.833056%\n",
      "test_avarage_loss: 0.005364, accuracy: 93.000000%\n",
      "end_time:  2022-02-25 10:18:29 \n",
      "\n",
      "start_time 2022-02-25 10:18:29\n",
      "Train Epoch6 \t Loss: 0.076983, accuracy: 95.312500%\n",
      "Train Epoch6 \t Loss: 0.062171, accuracy: 94.105817%\n",
      "Train Epoch6 \t Loss: 0.232087, accuracy: 93.959888%\n",
      "Train Epoch6 \t Loss: 0.170320, accuracy: 94.092608%\n",
      "test_avarage_loss: 0.008393, accuracy: 89.920000%\n",
      "end_time:  2022-02-25 10:21:51 \n",
      "\n",
      "start_time 2022-02-25 10:21:51\n",
      "Train Epoch7 \t Loss: 0.251890, accuracy: 90.625000%\n",
      "Train Epoch7 \t Loss: 0.053920, accuracy: 95.142327%\n",
      "Train Epoch7 \t Loss: 0.121183, accuracy: 94.892724%\n",
      "Train Epoch7 \t Loss: 0.072685, accuracy: 94.897218%\n",
      "test_avarage_loss: 0.009216, accuracy: 89.720000%\n",
      "end_time:  2022-02-25 10:25:10 \n",
      "\n",
      "start_time 2022-02-25 10:25:10\n",
      "Train Epoch8 \t Loss: 0.108023, accuracy: 96.875000%\n",
      "Train Epoch8 \t Loss: 0.115382, accuracy: 95.792079%\n",
      "Train Epoch8 \t Loss: 0.212946, accuracy: 95.848881%\n",
      "Train Epoch8 \t Loss: 0.063757, accuracy: 95.836794%\n",
      "test_avarage_loss: 0.007602, accuracy: 89.560000%\n",
      "end_time:  2022-02-25 10:28:31 \n",
      "\n",
      "start_time 2022-02-25 10:28:31\n",
      "Train Epoch9 \t Loss: 0.036933, accuracy: 100.000000%\n",
      "Train Epoch9 \t Loss: 0.156341, accuracy: 96.302599%\n",
      "Train Epoch9 \t Loss: 0.054988, accuracy: 96.113184%\n",
      "Train Epoch9 \t Loss: 0.202394, accuracy: 95.925042%\n",
      "test_avarage_loss: 0.006743, accuracy: 91.860000%\n",
      "end_time:  2022-02-25 10:31:49 \n",
      "\n",
      "start_time 2022-02-25 10:31:49\n",
      "Train Epoch10 \t Loss: 0.123534, accuracy: 93.750000%\n",
      "Train Epoch10 \t Loss: 0.207544, accuracy: 96.488243%\n",
      "Train Epoch10 \t Loss: 0.039833, accuracy: 96.735075%\n",
      "Train Epoch10 \t Loss: 0.030364, accuracy: 96.547965%\n",
      "test_avarage_loss: 0.004907, accuracy: 93.840000%\n",
      "end_time:  2022-02-25 10:35:13 \n",
      "\n",
      "start_time 2022-02-25 10:35:13\n",
      "Train Epoch11 \t Loss: 0.112245, accuracy: 95.312500%\n",
      "Train Epoch11 \t Loss: 0.073520, accuracy: 96.735767%\n",
      "Train Epoch11 \t Loss: 0.068426, accuracy: 96.719527%\n",
      "Train Epoch11 \t Loss: 0.030394, accuracy: 96.724460%\n",
      "test_avarage_loss: 0.005723, accuracy: 93.000000%\n",
      "end_time:  2022-02-25 10:38:34 \n",
      "\n",
      "start_time 2022-02-25 10:38:34\n",
      "Train Epoch12 \t Loss: 0.072791, accuracy: 95.312500%\n",
      "Train Epoch12 \t Loss: 0.049569, accuracy: 96.735767%\n",
      "Train Epoch12 \t Loss: 0.049746, accuracy: 96.805037%\n",
      "Train Epoch12 \t Loss: 0.065681, accuracy: 96.677741%\n",
      "test_avarage_loss: 0.004766, accuracy: 94.240000%\n",
      "end_time:  2022-02-25 10:42:03 \n",
      "\n",
      "Finished Training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#调用\n",
    "epoch = 12\n",
    "Loss = []\n",
    "Accuracy = []\n",
    "for epoch in range(1, epoch+1):\n",
    "    print(\"start_time\",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))\n",
    "    loss, acc = train_runner(model, device, trainloader, loss_function, optimizer, epoch)\n",
    "    Loss.append(loss)\n",
    "    Accuracy.append(acc)\n",
    "    test_runner(model, device, testloader)\n",
    "    print(\"end_time: \",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\\n')\n",
    "\n",
    "print('Finished Training')\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(Loss)\n",
    "plt.title('Loss')\n",
    "plt.show()\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(Accuracy)\n",
    "plt.title('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00190a00",
   "metadata": {},
   "source": [
    "## 7. 保存模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "70f9860c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GoogLeNetV2(\n",
      "  (conv1): ConvBNReLU(\n",
      "    (conv): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
      "    (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (maxpool1): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (conv2): ConvBNReLU(\n",
      "    (conv): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu): ReLU6(inplace=True)\n",
      "  )\n",
      "  (maxpool2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (inceptionA1): InceptionV2_A(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionA2): InceptionV2_A(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionD1): InceptionV2_D(\n",
      "    (branch1): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 160, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(320, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (inceptionB1): InceptionV2_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(576, 224, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 64, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(64, 96, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 128, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB2): InceptionV2_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(576, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 128, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 96, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(96, 128, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB3): InceptionV2_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 160, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionB4): InceptionV2_B(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 128, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 192, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (3): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (4): ConvBNReLU(\n",
      "        (conv): Conv2d(160, 160, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "        (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionD2): InceptionV2_D(\n",
      "    (branch1): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(128, 192, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): ConvBNReLU(\n",
      "        (conv): Conv2d(576, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(192, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "      (2): ConvBNReLU(\n",
      "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (inceptionC1): InceptionV2_C(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 352, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 160, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 160, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x3): ConvBNReLU(\n",
      "      (conv): Conv2d(160, 112, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(112, 112, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(112, 112, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(1024, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inceptionC2): InceptionV2_C(\n",
      "    (branch1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 352, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 160, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch2_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 160, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x1): ConvBNReLU(\n",
      "      (conv): Conv2d(1024, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (bn): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x3): ConvBNReLU(\n",
      "      (conv): Conv2d(192, 112, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv1x3): ConvBNReLU(\n",
      "      (conv): Conv2d(112, 112, kernel_size=[1, 3], stride=(1, 1), padding=[0, 1])\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch3_conv3x1): ConvBNReLU(\n",
      "      (conv): Conv2d(112, 112, kernel_size=[3, 1], stride=(1, 1), padding=[1, 0])\n",
      "      (bn): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU6(inplace=True)\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): ConvBNReLU(\n",
      "        (conv): Conv2d(1024, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU6(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "  (dropout): Dropout(p=0.5, inplace=False)\n",
      "  (fc): Linear(in_features=1024, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)\n",
    "torch.save(model, './models/googlenetv2-catvsdog.pth') #保存模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0a141a5",
   "metadata": {},
   "source": [
    "## 8. 模型测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dd90d95",
   "metadata": {},
   "source": [
    "下面使用一张猫狗大战测试集的图片进行模型的测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "80609ece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "概率： tensor([[7.9002e-06, 9.9999e-01]], device='cuda:0', grad_fn=<SoftmaxBackward>)\n",
      "预测类别： dog\n"
     ]
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    model = torch.load('./models/googlenetv2-catvsdog.pth') #加载模型\n",
    "    model = model.to(device)\n",
    "    model.eval()    #把模型转为test模式\n",
    "    \n",
    "    #读取要预测的图片\n",
    "    # 读取要预测的图片\n",
    "    img = Image.open(\"./images/test_dog.jpg\") # 读取图像\n",
    "    #img.show()\n",
    "    plt.imshow(img) # 显示图片\n",
    "    plt.axis('off') # 不显示坐标轴\n",
    "    plt.show()\n",
    "    \n",
    "    # 导入图片，图片扩展后为[1，1，32，32]\n",
    "    trans = transforms.Compose(\n",
    "        [\n",
    "            transforms.Resize((227,227)),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "            #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "    img = trans(img)\n",
    "    img = img.to(device)\n",
    "    img = img.unsqueeze(0)  #图片扩展多一维,因为输入到保存的模型中是4维的[batch_size,通道,长，宽]，而普通图片只有三维，[通道,长，宽]\n",
    "    \n",
    "    # 预测 \n",
    "    # 预测 \n",
    "    classes = ('cat', 'dog')\n",
    "    output = model(img)\n",
    "    prob = F.softmax(output,dim=1) #prob是2个分类的概率\n",
    "    print(\"概率：\",prob)\n",
    "    value, predicted = torch.max(output.data, 1)\n",
    "    predict = output.argmax(dim=1)\n",
    "    pred_class = classes[predicted.item()]\n",
    "    print(\"预测类别：\",pred_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd32c013",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-pytorch] *",
   "language": "python",
   "name": "conda-env-.conda-pytorch-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
